#pragma once

#include "create_mysql_client.hpp"

#include "chat_session_member.hxx"
#include "chat_session_member-odb.hxx"
#include "logger.hpp"

namespace xu
{
    class ManageSession
    {
    public:
        using ptr = std::shared_ptr<ManageSession>;

        ManageSession(const std::shared_ptr<odb::mysql::database> & db)
        :_db(db)
        {};

        bool Insert(Session & session)
        {
            try 
            {
                //获取事务对象开启事务
                odb::transaction trans(_db->begin());
                _db->persist(session);
                //提交事务
                trans.commit();
            }
            catch (std::exception &e) 
            {
                LOG_ERROR("插入会话数据出错： {}", e.what() );
                return false;
            }
            LOG_INFO("插入会话数据成功");
            return true; 
        }

        bool Insert(std::vector<Session> & session_list)
        {
            try 
            {
                //获取事务对象开启事务
                odb::transaction trans(_db->begin());
                for(auto & session : session_list)
                {
                    _db->persist(session);
                }
            
                //提交事务
                trans.commit();
            }
            catch (std::exception &e) 
            {
                LOG_ERROR("插入批量会话数据出错： {}", e.what() );
                return false;
            }
            LOG_INFO("插入批量会话数据成功");
            return true; 
        }

        void Delete(Session & session)
        {
            try 
            {
                // 开始事务
                odb::transaction t(_db->begin());
                typedef odb::query<Session> query;
                _db->erase_query<Session>(query::session_id == session.session_id()&&
                 query::user_id ==session.user_id());
                // 提交事务
                t.commit();

            } 
            catch (const odb::exception& e) 
            {
                LOG_ERROR("删除单个会话数据出错： {}", e.what() );
                return ;
            }

            LOG_INFO("删除单个会话数据成功");
        }   

        void Delete(const std::string  & ssid)
        {
             try 
            {
                // 开始事务
                odb::transaction t(_db->begin());
                typedef odb::query<Session> query;
                _db->erase_query<Session>(query::session_id == ssid);
                // 提交事务
                t.commit();

            } 
            catch (const odb::exception& e) 
            {
                LOG_ERROR("删除会话数据出错： {}", e.what() );
                return ;
            }

            LOG_INFO("删除会话数据成功");
        }   

        std::vector<std::string> SelectUserId(const std::string  & ssid)
        {
            std::vector<std::string> res;
            try 
            {
                odb::transaction trans(_db->begin());
                typedef odb::query<Session> query;
                typedef odb::result<Session> result;
                result r(_db->query<Session>(query::session_id == ssid));
                for (result::iterator i(r.begin()); i != r.end(); ++i) {
                    res.push_back(i->user_id());
                }
                trans.commit();
            }
            catch (std::exception &e) 
            {
                LOG_ERROR("通过会话查询用户失败:{}！", e.what());
                return std::vector<std::string>();
            }
            LOG_INFO("通过用户ID批量查询成功");
            return res;
        }

    private:
        private:
        std::shared_ptr<odb::mysql::database> _db;
    };


}
